#include "pch.h"

#include "math/float2.h"



namespace Math
{





	//////////////////////////////////////////////////////////////////////////
	float2::float2():
m_x(0),
	m_y(0)
{

}


//////////////////////////////////////////////////////////////////////////
float2::float2(scalar x, scalar y):
m_x(x),
	m_y(y)
{

}


//////////////////////////////////////////////////////////////////////////
float2::float2(const Math::float2 &rhs):
m_x(rhs.m_x),
	m_y(rhs.m_y)
{

}





//////////////////////////////////////////////////////////////////////////
void float2::operator =(const Math::float2 &rhs)
{
	this->m_x = rhs.m_x;
	this->m_y = rhs.m_y;
}


//////////////////////////////////////////////////////////////////////////
bool float2::operator ==(const float2 & rhs) const 
{
	return ((this->m_x == rhs.m_x) && (this->m_y == rhs.m_y));
}


//////////////////////////////////////////////////////////////////////////
bool float2::operator !=(const float2 & rhs) const 
{
	return ((this->m_x != rhs.m_x) || (this->m_y != rhs.m_y));
}


//////////////////////////////////////////////////////////////////////////
void float2::operator *=(scalar s)
{
	this->m_x *= s;
	this->m_y *= s;
}


//////////////////////////////////////////////////////////////////////////
void float2::operator +=(const float2 & rhs)
{
	this->m_x += rhs.m_x;
	this->m_y += rhs.m_y;
}


//////////////////////////////////////////////////////////////////////////
void float2::operator -=(const float2 & rhs)
{
	this->m_x -= rhs.m_x;
	this->m_y -= rhs.m_y;
}


//////////////////////////////////////////////////////////////////////////
float2 float2::operator - () const 
{
	return float2(-this->m_x, -this->m_y);
}


//////////////////////////////////////////////////////////////////////////
float2 float2::operator * (scalar s) const 
{
	return float2(this->m_x * s, this->m_y * s);
}


//////////////////////////////////////////////////////////////////////////
float2 float2::operator +(const float2 & rhs) const 
{
	return float2(this->m_x + rhs.m_x, this->m_y + rhs.m_y);
}


//////////////////////////////////////////////////////////////////////////
float2 float2::operator -(const float2 & rhs) const 
{
	return float2(this->m_x - rhs.m_x, this->m_y - rhs.m_y);
}





//////////////////////////////////////////////////////////////////////////
void float2::set(scalar x, scalar y)
{
	this->m_x = x;
	this->m_y = y;
}


//////////////////////////////////////////////////////////////////////////
void float2::setx(scalar x)
{
	this->m_x = x;
}


//////////////////////////////////////////////////////////////////////////
void float2::sety(scalar y)
{
	this->m_y = y;
}


//////////////////////////////////////////////////////////////////////////
scalar & float2::getx()
{
	return this->m_x;
}


//////////////////////////////////////////////////////////////////////////
scalar float2::getx() const 
{
	return this->m_x;
}


//////////////////////////////////////////////////////////////////////////
scalar & float2::gety()
{
	return this->m_y;
}


//////////////////////////////////////////////////////////////////////////
scalar float2::gety() const 
{
	return this->m_y;
}





//////////////////////////////////////////////////////////////////////////
scalar float2::length() const 
{
	return r_sqrt(this->m_x * this->m_x + this->m_y * this->m_y);
}


//////////////////////////////////////////////////////////////////////////
scalar float2::lengthsq() const
{
	return (this->m_x * this->m_x + this->m_y * this->m_y);
}


//////////////////////////////////////////////////////////////////////////
float2 float2::abs() const 
{
	return float2(r_abs(this->m_x), r_abs(this->m_y));
}





//////////////////////////////////////////////////////////////////////////
float2 float2::maximize(const float2 & f1, const float2 & f2)
{
	return float2(r_max(f1.m_x, f2.m_x), r_max(f1.m_y, f2.m_y));
}


//////////////////////////////////////////////////////////////////////////
float2 float2::minimize(const float2 & f1, const float2 & f2)
{
	return float2(r_min(f1.m_x, f2.m_x), r_min(f1.m_y, f2.m_y));
}


//////////////////////////////////////////////////////////////////////////
float2 float2::normalize(const float2 & f)
{
	scalar len = f.length();

	return float2(f.m_x / len, f.m_y / len);
}


//////////////////////////////////////////////////////////////////////////
float2 float2::less(const float2 & f1, const float2 & f2)
{
	float2 result;

	result.m_x = (f1.m_x < f2.m_x) ? 0.0f : 1.0f;
	result.m_y = (f1.m_y < f2.m_y) ? 0.0f : 1.0f;

	return result;
}


//////////////////////////////////////////////////////////////////////////
float2 float2::lessequal(const float2 & f1, const float2 & f2)
{
	float2 result;

	result.m_x = (f1.m_x <= f2.m_x) ? 0.0f : 1.0f;
	result.m_y = (f1.m_y <= f2.m_y) ? 0.0f : 1.0f;

	return result;
}


///
float2 float2::lerp(const float2 & f1, const float2 & f2, scalar s)
{
	return float2(f1.m_x + (f2.m_x - f1.m_x) * s,
		f1.m_y + (f2.m_y - f1.m_y) * s);
}


//////////////////////////////////////////////////////////////////////////
float2 float2::greater(const float2 & f1, const float2 & f2)
{
	float2 result;

	result.m_x = (f1.m_x > f2.m_x) ? 1.0f : 0.0f;
	result.m_y = (f1.m_y > f2.m_y) ? 1.0f : 0.0f;

	return result;
}


//////////////////////////////////////////////////////////////////////////
float2 float2::greaterequal(const Math::float2 &f1, const Math::float2 &f2)
{
	float2 result;

	result.m_x = (f1.m_x >= f2.m_x) ? 1.0f : 0.0f;
	result.m_y = (f1.m_y >= f2.m_y) ? 1.0f : 0.0f;

	return result;
}

}